home *** CD-ROM | disk | FTP | other *** search
/ Winzipper / Winzipper_ISO.iso / programming / oracle7 7.2 / OCI72 / CDEMO6.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-25  |  9.6 KB  |  369 lines
  1.  
  2. /* Copyright (c) 1991 by Oracle Corporation */
  3. /* 
  4.  *      -- cdemo6.cc --
  5.  *  An example program which illustrates how a C++ program
  6.  *  can use the OCI interface to access ORACLE database.
  7.  *
  8.  *  This program retrieves department name, given the
  9.  *  department number.
  10.  *  
  11.  *  The program queries the user for data as follows:
  12.  *   
  13.  *  Enter department number:
  14.  *   
  15.  *  The program terminates if -1 is entered
  16.  *  when the department number is requested.
  17.  */ 
  18. extern "C"
  19. {
  20. #include <stdio.h>
  21. #include <windows.h>
  22. #include <oratypes.h>
  23. #include <ociapr.h>
  24. /* demo constants and structs */
  25. #include <ocidem.h>
  26. } 
  27. extern "C"
  28. {
  29. #include <oratypes.h>
  30. #include <ocidfn.h>
  31. #include <ocidem.h>
  32. } 
  33. /* oparse flags */
  34. #define  DEFER_PARSE        1
  35. #define  NATIVE             1
  36. #define  VERSION_7          2 
  37. /* Class forward declarations */
  38. class connection;
  39. class cursor; 
  40. /*
  41.  * This class represents a connection to ORACLE database.
  42.  *
  43.  * NOTE: This connection class is just given as an example and 
  44.  * all possible operations on a connection have not been defined.
  45.  */
  46. class connection
  47. {
  48.   friend class cursor;
  49.   public:
  50.     connection() 
  51.       { state = not_connected;  
  52.         memset(&lda,0,sizeof(Lda_Def));
  53.         memset(&hda,0,HDA_SIZE); 
  54.       }
  55.     ~connection();
  56.     sword connect(const text *username, const text *password);
  57.     sword disconnect();
  58.     void display_error(FILE* file) const;
  59.   private:
  60.     Lda_Def lda;
  61.     ub1 hda[HDA_SIZE];
  62.     enum conn_state
  63.     {
  64.       not_connected,
  65.       connected
  66.     };
  67.     conn_state state;
  68. }; 
  69. /*
  70.  * This class represents an ORACLE cursor.
  71.  *
  72.  * NOTE: This cursor class is just given as an example and all
  73.  * possible operations on a cursor have not been defined.
  74.  */
  75. class cursor
  76. {
  77.   public:
  78.     cursor() 
  79.       {state = not_opened; conn = (connection *)0; }
  80.     ~cursor();
  81.     sword open(connection *conn_param);
  82.     sword close();
  83.     sword parse(const text *stmt)
  84.       { return (oparse(&cda, (text *)stmt, (sb4)-1, 
  85.                        DEFER_PARSE, (ub4) VERSION_7)); }
  86.     /* bind an input variable */
  87.     sword bind_by_position(sword sqlvnum, ub1 *progvar, 
  88.                            sword progvarlen, sword datatype, 
  89.                            sword scale, sb2 *indicator)
  90.       { return (obndrn(&cda, sqlvnum, progvar, progvarlen,
  91.                        datatype, scale, indicator, (text *)0, 
  92.                        -1, -1)); }
  93.     /* define an output variable */
  94.     sword define_by_position(sword position, ub1 *buf, 
  95.                              sword bufl, sword datatype, 
  96.                       
  97.       sword scale, sb2 *indicator, 
  98.                              ub2 *rlen, ub2 *rcode)
  99.       { return (odefin(&cda, position, buf, bufl, datatype, 
  100.                        scale, indicator,
  101.                        (text *)0, -1, -1, rlen, rcode)); }
  102.     sword describe(sword position, sb4 *dbsize, sb2 *dbtype, 
  103.                    sb1 *cbuf, sb4 *cbufl, sb4 *dsize, sb2 *prec,
  104.                    sb2 *scale, sb2 *nullok)
  105.       { return (odescr(&cda, position, dbsize, dbtype, 
  106.                        cbuf, cbufl, dsize,  prec, scale, nullok));
  107.       }
  108.     sword execute()
  109.       { return (oexec(&cda)); }
  110.     sword fetch()
  111.       { return (ofetch(&cda)); }
  112.     sword get_error_code() const
  113.       { return (cda.rc); }
  114.     void display_error( FILE* file) const;
  115.   private:
  116.     Cda_Def cda;
  117.     connection *conn;
  118.     enum cursor_state
  119.     {
  120.       not_opened,
  121.       opened
  122.     };
  123.     cursor_state state;
  124. }; 
  125. /*
  126.  * Error number macros
  127.  */
  128. #define CONERR_ALRCON -1            /* already connected */ 
  129. #define CONERR_NOTCON -2            /* not connected */ 
  130. #define CURERR_ALROPN -3            /* cursor is already open */
  131. #define CURERR_NOTOPN -4            /* cursor is not opened */
  132.  
  133.  
  134. /* exit status upon failure */
  135. #define  EXIT_FAILURE       1 
  136.  
  137. const text *username = (text *) "SCOTT";
  138. const text *password = (text *) "TIGER"; 
  139. /* define SQL statements to be used in the program */
  140. const text *seldept = (text *) "SELECT dname FROM dept WHERE deptno = :1"; 
  141. void err_report(FILE *file, text *errmsg, sword func_code);
  142. void myfflush(); 
  143. /* connection destructor */
  144. connection::~connection() 
  145. {
  146.   // disconnect if connection exists
  147.   if (state == connected)
  148.   {
  149.     if (disconnect())
  150.     {
  151.       display_error(stderr);
  152.     }
  153.   }
  154. } 
  155. /* connect to ORACLE */
  156. sword connection::connect(const text *username, const text *password)
  157. {
  158.   sword status; 
  159.   if (state == connected)
  160.   {
  161.     // this object is already connected
  162.     return (CONERR_ALRCON);
  163.   } 
  164.  
  165.   if ((status = olog(&lda, hda, (text *)username, -1,
  166.                      (text *)password, -1, (text *) 0, -1,
  167.                      OCI_LM_DEF)) == 0)
  168.   {
  169.     // successful login
  170.     state = connected;
  171.     printf("Connected to ORACLE as %s\n", username);
  172.   } 
  173.   return (status);
  174. } 
  175. /* disconnect from ORACLE */
  176. sword connection::disconnect()
  177. {
  178.   sword status; 
  179.   if (state == not_connected)
  180.   {
  181.     // this object has not been connected
  182.     return (CONERR_NOTCON);
  183.   } 
  184.   if ((status = ologof(&lda)) == 0)
  185.   {
  186.     // successful logout
  187.     state = not_connected;
  188.   } 
  189.   return (status);
  190. } 
  191. /* write error message to the given file */
  192. void connection::display_error(FILE *file) const
  193. {
  194.   if (lda.rc != 0)
  195.   {
  196.     sword n;
  197.     text msg[512]; 
  198.     n = oerhms((cda_def *)&lda, lda.rc, msg, (sword) sizeof(msg));
  199.     err_report(file, msg, lda.fc);
  200.   }
  201. } 
  202. /* cursor destructor */
  203. cursor::~cursor()
  204. {
  205.   if (state == opened)
  206.   {
  207.     if (close())
  208.       display_error(stderr);
  209.   }
  210. } 
  211. /* open the cursor */
  212. sword cursor::open(connection *conn_param)
  213. {
  214.   sword status; 
  215.   if (state == opened)
  216.   {
  217.     // this cursor has already been opened
  218.     return (CURERR_ALROPN);
  219.   } 
  220.   if ((status = oopen(&cda, &conn_param->lda, (text *)0, -1, -1, 
  221.                       (text *)0, -1)) == 0)
  222.   {
  223.     // successfull open
  224.     state = opened;
  225.     conn = conn_param;
  226.   } 
  227.   return (status);
  228. } 
  229. /* close the cursor */
  230. sword cursor::close()
  231. {
  232.   sword status; 
  233.   if (state == not_opened)
  234.   {
  235.     // this cursor has not been opened
  236.     return (CURERR_NOTOPN);
  237.   } 
  238.   if ((status = oclose(&cda)) == 0)
  239.   {
  240.     // successful cursor close
  241.     state = not_opened;
  242.     conn = (connection *)0;
  243.   } 
  244.   return (status);
  245. } 
  246. /* write error message to the given file */
  247. void cursor::display_error(FILE *file) const
  248. {
  249.   if (cda.rc != 0)
  250.   {
  251.     sword n;
  252.     text msg[512]; 
  253.     n = oerhms(&conn->lda, cda.rc, msg, (sword) sizeof(msg));
  254.     err_report(file, msg, cda.fc);
  255.   }
  256. } 
  257. int main()
  258. {
  259.     sword deptno;
  260.     sword len, dsize;
  261.     sb4   deptlen;
  262.     sb2   db_type;
  263.     sb1   name_buf[20];
  264.     text  *dept; 
  265. /* 
  266.  *  Connect to ORACLE and open a cursor.
  267.  *  Exit on any error.
  268.  */
  269.     connection conn;
  270.     if (conn.connect(username, password))
  271.     {
  272.       conn.display_error(stderr);
  273.       return(EXIT_FAILURE);
  274.     } 
  275.     cursor crsr;
  276.     if (crsr.open(&conn))
  277.     {
  278.       crsr.display_error(stderr);
  279.       return(EXIT_FAILURE);
  280.     } 
  281.     /* parse the SELDEPT statement */
  282.     if (crsr.parse(seldept))
  283.     {
  284.       crsr.display_error(stderr);
  285.       return(EXIT_FAILURE);
  286.     } 
  287.     /* bind the placeholder in the SELDEPT statement */
  288.     if (crsr.bind_by_position(1, (ub1 *) &deptno, 
  289.                               (sword) sizeof(deptno),
  290.                               INT_TYPE, -1, (sb2 *) 0))
  291.     {
  292.       crsr.display_error(stderr);
  293.       return(EXIT_FAILURE);
  294.     }   
  295.     /* describe the select-list field "dname" */
  296.     len = sizeof (name_buf);
  297.     if (crsr.describe(1, (sb4 *) &deptlen, &db_type,
  298.                       name_buf, (sb4 *) &len, (sb4 *) &dsize, 
  299.                      (sb2 *) 0, (sb2 *) 0, (sb2 *) 0))
  300.     {
  301.       crsr.display_error(stderr);
  302.       return(EXIT_FAILURE);
  303.     } 
  304.     /* allocate space for dept name now that you have length */
  305.     dept = new text((int) deptlen + 1); 
  306.     /* define the output variable for the select-list */
  307.     if (crsr.define_by_position(1, (ub1 *) dept, (sword)deptlen+1,
  308.                                 STRING_TYPE, -1, (sb2 *) 0, 
  309.                                (ub2 *) 0, (ub2 *) 0))
  310.     {
  311.       crsr.display_error(stderr);
  312.       delete dept;
  313.       return(EXIT_FAILURE);
  314.     } 
  315.     for (;;)
  316.     {
  317.         /* prompt for department number, */
  318.         /* break if given number == -1 */
  319.         printf("\nEnter department number (or -1 to EXIT): ");
  320.         while (scanf("%d", &deptno) != 1)
  321.         {
  322.           myfflush();
  323.           printf("Invalid input, please enter a number \
  324.                  (-1 to EXIT): ");
  325.         }
  326.         if (deptno == -1)
  327.         {
  328.           printf("Exiting... ");
  329.           break;
  330.         } 
  331.         /* display the name of the corresponding department */
  332.         if (crsr.execute() || crsr.fetch())
  333.         {
  334.           if (crsr.get_error_code() != NO_DATA_FOUND)
  335.           {
  336.             crsr.display_error(stderr);
  337.             delete dept;
  338.             return(EXIT_FAILURE);
  339.           }
  340.           else
  341.           printf("\n  The department number that you entered \
  342.                  doesn't exist.\n");
  343.         }
  344.         else
  345.        {
  346.        printf("\n  Department name = %s    \
  347.               Department number = %d\n", 
  348.               dept, deptno);
  349.        }
  350.     } 
  351.     delete dept;
  352.     printf ("\nG'day\n"); 
  353.   return 0;
  354. } 
  355. void err_report(FILE *file, text *errmsg, sword func_code)
  356. {
  357.     fprintf(file, "\n-- ORACLE error--\n\n%s\n", errmsg);
  358.     if (func_code > 0)
  359.         fprintf(file, "Processing OCI function %s\n",
  360.             oci_func_tab[func_code]);
  361. } 
  362. void myfflush()
  363. {
  364.   eb1 buf[50];
  365.  
  366.   fgets((char *) buf, 50, stdin);
  367. }
  368.   
  369.